[INFO] cloning repository https://github.com/samsheff/pokerbot2
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/samsheff/pokerbot2" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fsamsheff%2Fpokerbot2", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fsamsheff%2Fpokerbot2'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 1c7e91e96ce96906dfab3973044dd2b88afe682a
[INFO] fixing samsheff/pokerbot2 against try#622891a4e29178280638a6b63a8908bde2c0c854+cargoflags=-Zfix-edition=start=2015 for pr-157817-2
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fsamsheff%2Fpokerbot2" "/workspace/builds/worker-7-tc1/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-7-tc1/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/samsheff/pokerbot2
[INFO] finished tweaking git repo https://github.com/samsheff/pokerbot2
[INFO] tweaked toml for git repo https://github.com/samsheff/pokerbot2 written to /workspace/builds/worker-7-tc1/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/samsheff/pokerbot2 on toolchain 622891a4e29178280638a6b63a8908bde2c0c854
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate git repo https://github.com/samsheff/pokerbot2 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] [stderr]  Downloading crates ...
[INFO] [stderr]   Downloaded postgres-types v0.2.12
[INFO] [stderr]   Downloaded postgres-protocol v0.6.10
[INFO] [stderr]   Downloaded tokio-postgres v0.7.16
[INFO] [stderr]   Downloaded actix-ws v0.3.1
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc1/source:/opt/rustwide/workdir:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:3a6becf2bc8dde7f3fa57ede90e4f284e72d296796fc446bbb1e2c7cc0530151" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 08b3a850d7454f299f9f78d21ce8fb67c46a2dda151dbeb4f05afa1bd63e3b97
[INFO] running `Command { std: "docker" "start" "08b3a850d7454f299f9f78d21ce8fb67c46a2dda151dbeb4f05afa1bd63e3b97", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-w" "/opt/rustwide/workdir" "--user" "0:0" "08b3a850d7454f299f9f78d21ce8fb67c46a2dda151dbeb4f05afa1bd63e3b97" "/opt/rustwide/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "08b3a850d7454f299f9f78d21ce8fb67c46a2dda151dbeb4f05afa1bd63e3b97", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=" "-e" "RUSTDOCFLAGS=" "-w" "/opt/rustwide/workdir" "--user" "0:0" "08b3a850d7454f299f9f78d21ce8fb67c46a2dda151dbeb4f05afa1bd63e3b97" "/opt/rustwide/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "fix" "--allow-no-vcs" "--allow-dirty" "--frozen" "--all" "--all-targets" "--message-format=json" "-Zfix-edition=start=2015", kill_on_drop: false }`
[INFO] [stderr]    Compiling unicode-ident v1.0.23
[INFO] [stderr]    Compiling libc v0.2.181
[INFO] [stderr]     Checking smallvec v1.15.1
[INFO] [stderr]     Checking bytes v1.11.1
[INFO] [stderr]     Checking log v0.4.29
[INFO] [stderr]     Checking itoa v1.0.17
[INFO] [stderr]     Checking powerfmt v0.2.0
[INFO] [stderr]    Compiling parking_lot_core v0.9.12
[INFO] [stderr]    Compiling getrandom v0.3.4
[INFO] [stderr]    Compiling serde_core v1.0.228
[INFO] [stderr]     Checking memchr v2.8.0
[INFO] [stderr]    Compiling typenum v1.19.0
[INFO] [stderr]     Checking num_threads v0.1.7
[INFO] [stderr]     Checking time-core v0.1.8
[INFO] [stderr]     Checking num-conv v0.2.0
[INFO] [stderr]    Compiling serde v1.0.228
[INFO] [stderr]    Compiling generic-array v0.14.7
[INFO] [stderr]    Compiling zerocopy v0.8.39
[INFO] [stderr]     Checking subtle v2.6.1
[INFO] [stderr]     Checking futures-sink v0.3.31
[INFO] [stderr]     Checking hashbrown v0.16.1
[INFO] [stderr]     Checking cpufeatures v0.2.17
[INFO] [stderr]     Checking futures-task v0.3.31
[INFO] [stderr]     Checking futures-io v0.3.31
[INFO] [stderr]     Checking slab v0.4.12
[INFO] [stderr]    Compiling proc-macro2 v1.0.106
[INFO] [stderr]     Checking base64 v0.22.1
[INFO] [stderr]     Checking percent-encoding v2.3.2
[INFO] [stderr]     Checking futures-channel v0.3.31
[INFO] [stderr]     Checking stable_deref_trait v1.2.1
[INFO] [stderr]    Compiling anyhow v1.0.101
[INFO] [stderr]     Checking tinyvec v1.10.0
[INFO] [stderr]     Checking unicode-properties v0.1.4
[INFO] [stderr]     Checking deranged v0.5.6
[INFO] [stderr]     Checking unicode-bidi v0.3.18
[INFO] [stderr]    Compiling crossbeam-utils v0.8.21
[INFO] [stderr]     Checking byteorder v1.5.0
[INFO] [stderr]     Checking fallible-iterator v0.2.0
[INFO] [stderr]     Checking siphasher v1.0.2
[INFO] [stderr]     Checking fixedbitset v0.4.2
[INFO] [stderr]     Checking phf_shared v0.13.1
[INFO] [stderr]    Compiling zmij v1.0.20
[INFO] [stderr]    Compiling quote v1.0.44
[INFO] [stderr]     Checking unicode-normalization v0.1.25
[INFO] [stderr]     Checking indexmap v2.13.0
[INFO] [stderr]    Compiling rayon-core v1.13.0
[INFO] [stderr]     Checking writeable v0.6.2
[INFO] [stderr]     Checking litemap v0.8.1
[INFO] [stderr]     Checking tracing-core v0.1.36
[INFO] [stderr]     Checking phf v0.13.1
[INFO] [stderr]    Compiling serde_json v1.0.149
[INFO] [stderr]     Checking either v1.15.0
[INFO] [stderr]    Compiling syn v2.0.114
[INFO] [stderr]    Compiling const_format_proc_macros v0.2.34
[INFO] [stderr]     Checking errno v0.3.14
[INFO] [stderr]     Checking mio v1.1.1
[INFO] [stderr]     Checking signal-hook-registry v1.4.8
[INFO] [stderr]     Checking socket2 v0.6.2
[INFO] [stderr]     Checking rand_core v0.9.5
[INFO] [stderr]     Checking crossbeam-epoch v0.9.18
[INFO] [stderr]    Compiling jobserver v0.1.34
[INFO] [stderr]     Checking time v0.3.47
[INFO] [stderr]     Checking whoami v2.1.1
[INFO] [stderr]     Checking stringprep v0.1.5
[INFO] [stderr]     Checking parking_lot v0.12.5
[INFO] [stderr]    Compiling icu_normalizer_data v2.1.1
[INFO] [stderr]    Compiling icu_properties_data v2.1.2
[INFO] [stderr]     Checking block-buffer v0.10.4
[INFO] [stderr]     Checking crypto-common v0.1.7
[INFO] [stderr]     Checking crossbeam-deque v0.8.6
[INFO] [stderr]     Checking digest v0.10.7
[INFO] [stderr]     Checking fnv v1.0.7
[INFO] [stderr]     Checking fixedbitset v0.5.7
[INFO] [stderr]     Checking local-waker v0.1.4
[INFO] [stderr]     Checking petgraph v0.6.5
[INFO] [stderr]     Checking alloc-no-stdlib v2.0.4
[INFO] [stderr]    Compiling crc32fast v1.5.0
[INFO] [stderr]     Checking http v0.2.12
[INFO] [stderr]     Checking md-5 v0.10.6
[INFO] [stderr]     Checking sha2 v0.10.9
[INFO] [stderr]     Checking hmac v0.12.1
[INFO] [stderr]     Checking alloc-stdlib v0.2.2
[INFO] [stderr]    Compiling cc v1.2.55
[INFO] [stderr]     Checking aho-corasick v1.1.4
[INFO] [stderr]     Checking petgraph v0.7.1
[INFO] [stderr]     Checking regex-syntax v0.8.9
[INFO] [stderr]     Checking simd-adler32 v0.3.8
[INFO] [stderr]     Checking miniz_oxide v0.8.9
[INFO] [stderr]    Compiling httparse v1.10.1
[INFO] [stderr]     Checking rayon v1.11.0
[INFO] [stderr]     Checking brotli-decompressor v5.0.0
[INFO] [stderr]     Checking const_format v0.2.35
[INFO] [stderr]     Checking simplelog v0.12.2
[INFO] [stderr]    Compiling num-traits v0.2.19
[INFO] [stderr]    Compiling tracing v0.1.44
[INFO] [stderr]     Checking actix-utils v3.0.1
[INFO] [stderr]     Checking bytestring v1.5.0
[INFO] [stderr]     Checking form_urlencoded v1.2.2
[INFO] [stderr]     Checking actix-service v2.0.3
[INFO] [stderr]     Checking bitflags v2.10.0
[INFO] [stderr]    Compiling regex-lite v0.1.9
[INFO] [stderr]     Checking utf8_iter v1.0.4
[INFO] [stderr]     Checking flate2 v1.1.9
[INFO] [stderr]    Compiling cookie v0.16.2
[INFO] [stderr]     Checking local-channel v0.1.5
[INFO] [stderr]     Checking uuid v1.20.0
[INFO] [stderr]     Checking sha1 v0.10.6
[INFO] [stderr]     Checking socket2 v0.5.10
[INFO] [stderr]    Compiling zstd-sys v2.0.16+zstd.1.5.7
[INFO] [stderr]     Checking encoding_rs v0.8.35
[INFO] [stderr]    Compiling actix-router v0.5.3
[INFO] [stderr]     Checking foldhash v0.1.5
[INFO] [stderr]     Checking mime v0.3.17
[INFO] [stderr]     Checking brotli v8.0.2
[INFO] [stderr]     Checking ryu v1.0.23
[INFO] [stderr]     Checking httpdate v1.0.3
[INFO] [stderr]     Checking language-tags v0.3.2
[INFO] [stderr]    Compiling thiserror v2.0.18
[INFO] [stderr]     Checking regex-automata v0.4.14
[INFO] [stderr]     Checking num-integer v0.1.46
[INFO] [stderr]    Compiling ring v0.17.14
[INFO] [stderr]     Checking impl-more v0.1.9
[INFO] [stderr]     Checking getrandom v0.2.17
[INFO] [stderr]     Checking rand_core v0.6.4
[INFO] [stderr]     Checking base64ct v1.8.3
[INFO] [stderr]     Checking untrusted v0.9.0
[INFO] [stderr]     Checking blake2 v0.10.6
[INFO] [stderr]     Checking pem v3.0.6
[INFO] [stderr]     Checking num-bigint v0.4.6
[INFO] [stderr]     Checking utf8parse v0.2.2
[INFO] [stderr]     Checking is_terminal_polyfill v1.70.2
[INFO] [stderr]     Checking password-hash v0.5.0
[INFO] [stderr]     Checking anstyle-parse v0.2.7
[INFO] [stderr]     Checking colorchoice v1.0.4
[INFO] [stderr]     Checking anstyle-query v1.1.5
[INFO] [stderr]     Checking anstyle v1.0.13
[INFO] [stderr]     Checking clap_lex v1.0.0
[INFO] [stderr]     Checking strsim v0.11.1
[INFO] [stderr]     Checking num_cpus v1.17.0
[INFO] [stderr]     Checking argon2 v0.5.3
[INFO] [stderr]     Checking anstream v0.6.21
[INFO] [stderr]     Checking ppv-lite86 v0.2.21
[INFO] [stderr]     Checking clap_builder v4.5.58
[INFO] [stderr]     Checking rand_chacha v0.9.0
[INFO] [stderr]     Checking rand v0.9.2
[INFO] [stderr]    Compiling synstructure v0.13.2
[INFO] [stderr]     Checking postgres-protocol v0.6.10
[INFO] [stderr]     Checking regex v1.12.3
[INFO] [stderr]     Checking postgres-types v0.2.12
[INFO] [stderr]    Compiling tokio-macros v2.6.0
[INFO] [stderr]    Compiling serde_derive v1.0.228
[INFO] [stderr]    Compiling futures-macro v0.3.31
[INFO] [stderr]     Checking tokio v1.49.0
[INFO] [stderr]    Compiling zerofrom-derive v0.1.6
[INFO] [stderr]    Compiling yoke-derive v0.8.1
[INFO] [stderr]    Compiling zerovec-derive v0.11.2
[INFO] [stderr]     Checking futures-util v0.3.31
[INFO] [stderr]    Compiling displaydoc v0.2.5
[INFO] [stderr]     Checking zerofrom v0.1.6
[INFO] [stderr]    Compiling async-trait v0.1.89
[INFO] [stderr]     Checking yoke v0.8.1
[INFO] [stderr]     Checking zerovec v0.11.5
[INFO] [stderr]     Checking zerotrie v0.2.3
[INFO] [stderr]    Compiling tracing-attributes v0.1.31
[INFO] [stderr]    Compiling derive_more-impl v2.1.1
[INFO] [stderr]     Checking tinystr v0.8.2
[INFO] [stderr]     Checking potential_utf v0.1.4
[INFO] [stderr]     Checking icu_collections v2.1.1
[INFO] [stderr]     Checking icu_locale_core v2.1.1
[INFO] [stderr]    Compiling actix-web-codegen v4.3.0
[INFO] [stderr]    Compiling actix-macros v0.2.4
[INFO] [stderr]     Checking serde_urlencoded v0.7.1
[INFO] [stderr]    Compiling thiserror-impl v2.0.18
[INFO] [stderr]    Compiling clap_derive v4.5.55
[INFO] [stderr]     Checking futures-executor v0.3.31
[INFO] [stderr]     Checking futures v0.3.31
[INFO] [stderr]     Checking icu_provider v2.1.1
[INFO] [stderr]     Checking rbp-core v1.0.0 (/opt/rustwide/workdir/crates/util)
[INFO] [stderr]     Checking tokio-util v0.7.18
[INFO] [stderr]     Checking actix-rt v2.11.0
[INFO] [stderr]     Checking icu_properties v2.1.2
[INFO] [stderr]     Checking icu_normalizer v2.1.1
[INFO] [stderr]     Checking derive_more v2.1.1
[INFO] [stderr]     Checking simple_asn1 v0.6.3
[INFO] [stderr]     Checking actix-server v2.6.0
[INFO] [stderr]     Checking jsonwebtoken v9.3.1
[INFO] [stderr]     Checking rbp-cards v1.0.0 (/opt/rustwide/workdir/crates/cards)
[INFO] [stderr]     Checking rbp-transport v1.0.0 (/opt/rustwide/workdir/crates/transport)
[INFO] [stderr]     Checking tokio-postgres v0.7.16
[INFO] [stderr]     Checking h2 v0.3.27
[INFO] [stderr]     Checking actix-codec v0.5.2
[INFO] [stderr]     Checking rbp-mccfr v1.0.0 (/opt/rustwide/workdir/crates/mccfr)
[INFO] [stderr]     Checking clap v4.5.58
[INFO] [stderr]     Checking rbp-gameplay v1.0.0 (/opt/rustwide/workdir/crates/gameplay)
[INFO] [stderr]     Checking idna_adapter v1.2.1
[INFO] [stderr]     Checking idna v1.1.0
[INFO] [stderr]     Checking url v2.5.8
[INFO] [stderr]     Checking rbp-database v1.0.0 (/opt/rustwide/workdir/crates/database)
[INFO] [stderr]     Checking rbp-nlhe v1.0.0 (/opt/rustwide/workdir/crates/nlhe)
[INFO] [stderr]     Checking rbp-clustering v1.0.0 (/opt/rustwide/workdir/crates/clustering)
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^   ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:29:17
[INFO] [stdout]     |
[INFO] [stdout]  29 | pub struct Game<const P: usize = { rbp_core::N }> {
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Game`
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^   ------------ type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::root`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:59:6
[INFO] [stdout]     |
[INFO] [stdout]  59 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::root`
[INFO] [stdout] ...
[INFO] [stdout]  64 |     pub fn root() -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] 201 |         // 4 folds (UTG–BTN) + SB calls + BB checks → flop
[INFO] [stdout] 202 |         let game = game.apply(Action::Fold);
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 203 |         let game = game.apply(Action::Fold);
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 204 |         let game = game.apply(Action::Fold);
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 205 |         let game = game.apply(Action::Fold);
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 206 |         let game = game.apply(Action::Call(1));
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 207 |         let game = game.apply(Action::Check);
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 208 |         let flop = game.deck().deal(Street::Pref);
[INFO] [stdout]     |                         ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::deck`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:595:6
[INFO] [stdout]     |
[INFO] [stdout] 595 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::deck`
[INFO] [stdout] ...
[INFO] [stdout] 601 |     pub fn deck(&self) -> Deck {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 209 |         let game = game.apply(Action::Draw(flop));
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 210 |         assert_eq!(game.street(), Street::Flop);
[INFO] [stdout]     |                         ------ type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::street`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:128:6
[INFO] [stdout]     |
[INFO] [stdout] 128 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::street`
[INFO] [stdout] ...
[INFO] [stdout] 171 |     pub fn street(&self) -> Street {
[INFO] [stdout]     |            ------ required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 213 |             .choices(depth)
[INFO] [stdout]     |              ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::choices`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:682:6
[INFO] [stdout]     |
[INFO] [stdout] 682 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::choices`
[INFO] [stdout] ...
[INFO] [stdout] 685 |     pub fn choices(&self, depth: usize) -> Path {
[INFO] [stdout]     |            ------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 217 |         for amount in game.to_raise()..game.to_shove() {
[INFO] [stdout]     |                            -------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::to_raise`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:486:6
[INFO] [stdout]     |
[INFO] [stdout] 486 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::to_raise`
[INFO] [stdout] ...
[INFO] [stdout] 508 |     pub fn to_raise(&self) -> Chips {
[INFO] [stdout]     |            -------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 217 |         for amount in game.to_raise()..game.to_shove() {
[INFO] [stdout]     |                                             -------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::to_shove`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:486:6
[INFO] [stdout]     |
[INFO] [stdout] 486 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::to_shove`
[INFO] [stdout] ...
[INFO] [stdout] 502 |     pub fn to_shove(&self) -> Chips {
[INFO] [stdout]     |            -------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 219 |             if game.is_allowed(&action) {
[INFO] [stdout]     |                     ---------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::is_allowed`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::is_allowed`
[INFO] [stdout] ...
[INFO] [stdout] 251 |     pub fn is_allowed(&self, action: &Action) -> bool {
[INFO] [stdout]     |            ---------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:200:13
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 220 |                 let edge = NlheEdge::from(game.edgify(action, depth));
[INFO] [stdout]     |                                                ------ type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::edgify`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:682:6
[INFO] [stdout]     |
[INFO] [stdout] 682 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::edgify`
[INFO] [stdout] ...
[INFO] [stdout] 714 |     pub fn edgify(&self, action: Action, depth: usize) -> Edge {
[INFO] [stdout]     |            ------ required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 200 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^   ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:29:17
[INFO] [stdout]     |
[INFO] [stdout]  29 | pub struct Game<const P: usize = { rbp_core::N }> {
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Game`
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^   ------------ type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::root`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:59:6
[INFO] [stdout]     |
[INFO] [stdout]  59 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::root`
[INFO] [stdout] ...
[INFO] [stdout]  64 |     pub fn root() -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] 235 |         // 4 folds (UTG–BTN) + SB calls + BB checks → flop
[INFO] [stdout] 236 |         let game = game.apply(Action::Fold);
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 237 |         let game = game.apply(Action::Fold);
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 238 |         let game = game.apply(Action::Fold);
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 239 |         let game = game.apply(Action::Fold);
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 240 |         let game = game.apply(Action::Call(1));
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 241 |         let game = game.apply(Action::Check);
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 242 |         let flop = game.deck().deal(Street::Pref);
[INFO] [stdout]     |                         ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::deck`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:595:6
[INFO] [stdout]     |
[INFO] [stdout] 595 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::deck`
[INFO] [stdout] ...
[INFO] [stdout] 601 |     pub fn deck(&self) -> Deck {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 243 |         let game = game.apply(Action::Draw(flop));
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 244 |         let game = game.apply(Action::Check);
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 245 |         let game = game.apply(Action::Check);
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 246 |         let turn = game.deck().deal(Street::Flop);
[INFO] [stdout]     |                         ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::deck`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:595:6
[INFO] [stdout]     |
[INFO] [stdout] 595 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::deck`
[INFO] [stdout] ...
[INFO] [stdout] 601 |     pub fn deck(&self) -> Deck {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 247 |         let game = game.apply(Action::Draw(turn));
[INFO] [stdout]     |                         ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::apply`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::apply`
[INFO] [stdout] ...
[INFO] [stdout] 186 |     pub fn apply(&self, action: Action) -> Self {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 248 |         assert_eq!(game.street(), Street::Turn);
[INFO] [stdout]     |                         ------ type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::street`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:128:6
[INFO] [stdout]     |
[INFO] [stdout] 128 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::street`
[INFO] [stdout] ...
[INFO] [stdout] 171 |     pub fn street(&self) -> Street {
[INFO] [stdout]     |            ------ required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 251 |             .choices(depth)
[INFO] [stdout]     |              ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::choices`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:682:6
[INFO] [stdout]     |
[INFO] [stdout] 682 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::choices`
[INFO] [stdout] ...
[INFO] [stdout] 685 |     pub fn choices(&self, depth: usize) -> Path {
[INFO] [stdout]     |            ------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 255 |         for amount in game.to_raise()..game.to_shove() {
[INFO] [stdout]     |                            -------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::to_raise`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:486:6
[INFO] [stdout]     |
[INFO] [stdout] 486 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::to_raise`
[INFO] [stdout] ...
[INFO] [stdout] 508 |     pub fn to_raise(&self) -> Chips {
[INFO] [stdout]     |            -------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 255 |         for amount in game.to_raise()..game.to_shove() {
[INFO] [stdout]     |                                             -------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::to_shove`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:486:6
[INFO] [stdout]     |
[INFO] [stdout] 486 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::to_shove`
[INFO] [stdout] ...
[INFO] [stdout] 502 |     pub fn to_shove(&self) -> Chips {
[INFO] [stdout]     |            -------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:234:13
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 257 |             let edge = NlheEdge::from(game.edgify(action, depth));
[INFO] [stdout]     |                                            ------ type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::edgify`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:682:6
[INFO] [stdout]     |
[INFO] [stdout] 682 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::edgify`
[INFO] [stdout] ...
[INFO] [stdout] 714 |     pub fn edgify(&self, action: Action, depth: usize) -> Edge {
[INFO] [stdout]     |            ------ required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 234 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:317:13
[INFO] [stdout]     |
[INFO] [stdout] 317 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^   ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:29:17
[INFO] [stdout]     |
[INFO] [stdout]  29 | pub struct Game<const P: usize = { rbp_core::N }> {
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Game`
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 317 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:317:13
[INFO] [stdout]     |
[INFO] [stdout] 317 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^   ------------ type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::root`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:59:6
[INFO] [stdout]     |
[INFO] [stdout]  59 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::root`
[INFO] [stdout] ...
[INFO] [stdout]  64 |     pub fn root() -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 317 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:317:13
[INFO] [stdout]     |
[INFO] [stdout] 317 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] 318 |         for a1 in game.legal() {
[INFO] [stdout]     |                        ----- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::legal`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:177:6
[INFO] [stdout]     |
[INFO] [stdout] 177 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::legal`
[INFO] [stdout] ...
[INFO] [stdout] 217 |     pub fn legal(&self) -> Vec<Action> {
[INFO] [stdout]     |            ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 317 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:317:13
[INFO] [stdout]     |
[INFO] [stdout] 317 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] 318 |         for a1 in game.legal() {
[INFO] [stdout] 319 |             let e1 = NlheEdge::from(game.edgify(a1, depth));
[INFO] [stdout]     |                                          ------ type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::edgify`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:682:6
[INFO] [stdout]     |
[INFO] [stdout] 682 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::edgify`
[INFO] [stdout] ...
[INFO] [stdout] 714 |     pub fn edgify(&self, action: Action, depth: usize) -> Edge {
[INFO] [stdout]     |            ------ required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 317 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:317:13
[INFO] [stdout]     |
[INFO] [stdout] 317 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 320 |             let a2 = game.actionize(Edge::from(e1));
[INFO] [stdout]     |                           --------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::actionize`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:682:6
[INFO] [stdout]     |
[INFO] [stdout] 682 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::actionize`
[INFO] [stdout] ...
[INFO] [stdout] 701 |     pub fn actionize(&self, edge: Edge) -> Action {
[INFO] [stdout]     |            --------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 317 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:317:13
[INFO] [stdout]     |
[INFO] [stdout] 317 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 321 |             let e2 = NlheEdge::from(game.edgify(a2, depth));
[INFO] [stdout]     |                                          ------ type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::edgify`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:682:6
[INFO] [stdout]     |
[INFO] [stdout] 682 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::edgify`
[INFO] [stdout] ...
[INFO] [stdout] 714 |     pub fn edgify(&self, action: Action, depth: usize) -> Edge {
[INFO] [stdout]     |            ------ required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 317 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:332:13
[INFO] [stdout]     |
[INFO] [stdout] 332 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^   ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:29:17
[INFO] [stdout]     |
[INFO] [stdout]  29 | pub struct Game<const P: usize = { rbp_core::N }> {
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Game`
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 332 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:332:13
[INFO] [stdout]     |
[INFO] [stdout] 332 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^   ------------ type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::root`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:59:6
[INFO] [stdout]     |
[INFO] [stdout]  59 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::root`
[INFO] [stdout] ...
[INFO] [stdout]  64 |     pub fn root() -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 332 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:332:13
[INFO] [stdout]     |
[INFO] [stdout] 332 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 335 |             .choices(depth)
[INFO] [stdout]     |              ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::choices`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:682:6
[INFO] [stdout]     |
[INFO] [stdout] 682 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::choices`
[INFO] [stdout] ...
[INFO] [stdout] 685 |     pub fn choices(&self, depth: usize) -> Path {
[INFO] [stdout]     |            ------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 332 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:332:13
[INFO] [stdout]     |
[INFO] [stdout] 332 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 339 |         for amount in game.to_raise()..game.to_shove() {
[INFO] [stdout]     |                            -------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::to_raise`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:486:6
[INFO] [stdout]     |
[INFO] [stdout] 486 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::to_raise`
[INFO] [stdout] ...
[INFO] [stdout] 508 |     pub fn to_raise(&self) -> Chips {
[INFO] [stdout]     |            -------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 332 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:332:13
[INFO] [stdout]     |
[INFO] [stdout] 332 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 339 |         for amount in game.to_raise()..game.to_shove() {
[INFO] [stdout]     |                                             -------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::to_shove`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:486:6
[INFO] [stdout]     |
[INFO] [stdout] 486 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::to_shove`
[INFO] [stdout] ...
[INFO] [stdout] 502 |     pub fn to_shove(&self) -> Chips {
[INFO] [stdout]     |            -------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 332 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Game<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:332:13
[INFO] [stdout]     |
[INFO] [stdout] 332 |         let game = Game::root();
[INFO] [stdout]     |             ^^^^
[INFO] [stdout] ...
[INFO] [stdout] 341 |             let edge = NlheEdge::from(game.edgify(raise, depth));
[INFO] [stdout]     |                                            ------ type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::edgify`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:682:6
[INFO] [stdout]     |
[INFO] [stdout] 682 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::edgify`
[INFO] [stdout] ...
[INFO] [stdout] 714 |     pub fn edgify(&self, action: Action, depth: usize) -> Edge {
[INFO] [stdout]     |            ------ required by a bound in this associated function
[INFO] [stdout] help: consider giving `game` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 332 |         let game: rbp_gameplay::Game<P> = Game::root();
[INFO] [stdout]     |                 +++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^   ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:36:20
[INFO] [stdout]     |
[INFO] [stdout]  36 | pub struct Partial<const P: usize = { rbp_core::N }> {
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Partial`
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^   ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout]     = note: required for `rbp_gameplay::Partial<_>` to implement `From<(rbp_gameplay::Turn, rbp_gameplay::Arrangement)>`
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] 350 |             .push(Action::Fold)
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] 350 |             .push(Action::Fold)
[INFO] [stdout] 351 |             .push(Action::Fold)
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 352 |             .push(Action::Fold)
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 353 |             .push(Action::Fold)
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 354 |             .push(Action::Call(1))
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 355 |             .push(Action::Check)
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 356 |             .push(Action::Raise(3))
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 357 |             .push(Action::Raise(9))
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 358 |             .push(Action::Call(6));
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 360 |         let info = NlheInfo::from((recall.subgame(), abs, recall.choices()));
[INFO] [stdout]     |                                           ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `subgame`
[INFO] [stdout]    --> crates/gameplay/src/recall.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 | pub trait Recall<const P: usize = { rbp_core::N }> {
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Recall::subgame`
[INFO] [stdout] ...
[INFO] [stdout]  88 |     fn subgame(&self) -> Path {
[INFO] [stdout]     |        ------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 360 |         let info = NlheInfo::from((recall.subgame(), abs, recall.choices()));
[INFO] [stdout]     |                                           ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout]     = note: required for `rbp_gameplay::Partial<_>` to implement `rbp_gameplay::Recall<_>`
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 360 |         let info = NlheInfo::from((recall.subgame(), abs, recall.choices()));
[INFO] [stdout]     |                                                                  ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Recall::choices`
[INFO] [stdout]    --> crates/gameplay/src/recall.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 | pub trait Recall<const P: usize = { rbp_core::N }> {
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Recall::choices`
[INFO] [stdout] ...
[INFO] [stdout] 100 |     fn choices(&self) -> Path {
[INFO] [stdout]     |        ------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 360 |         let info = NlheInfo::from((recall.subgame(), abs, recall.choices()));
[INFO] [stdout]     |                                                                  ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout]     = note: required for `rbp_gameplay::Partial<_>` to implement `rbp_gameplay::Recall<_>`
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 362 |             .subgame()
[INFO] [stdout]     |              ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `subgame`
[INFO] [stdout]    --> crates/gameplay/src/recall.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 | pub trait Recall<const P: usize = { rbp_core::N }> {
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Recall::subgame`
[INFO] [stdout] ...
[INFO] [stdout]  88 |     fn subgame(&self) -> Path {
[INFO] [stdout]     |        ------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:349:13
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 362 |             .subgame()
[INFO] [stdout]     |              ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout]     = note: required for `rbp_gameplay::Partial<_>` to implement `rbp_gameplay::Recall<_>`
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 349 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^   ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:36:20
[INFO] [stdout]     |
[INFO] [stdout]  36 | pub struct Partial<const P: usize = { rbp_core::N }> {
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Partial`
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^   ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout]     = note: required for `rbp_gameplay::Partial<_>` to implement `From<(rbp_gameplay::Turn, rbp_gameplay::Arrangement)>`
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] 376 |             .push(Action::Fold)
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] 376 |             .push(Action::Fold)
[INFO] [stdout] 377 |             .push(Action::Fold)
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 378 |             .push(Action::Fold)
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 379 |             .push(Action::Fold)
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 380 |             .push(Action::Call(1))
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 381 |             .push(Action::Check)
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 382 |             .push(Action::Raise(7)); // arbitrary amount
[INFO] [stdout]     |              ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Partial::<P>::push`
[INFO] [stdout]    --> crates/gameplay/src/partial.rs:300:6
[INFO] [stdout]     |
[INFO] [stdout] 300 | impl<const P: usize> Partial<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Partial::<P>::push`
[INFO] [stdout] ...
[INFO] [stdout] 309 |     pub fn push(&self, action: Action) -> Self {
[INFO] [stdout]     |            ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 384 |         let _actual_game = recall.head();
[INFO] [stdout]     |                                   ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `head`
[INFO] [stdout]    --> crates/gameplay/src/recall.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 | pub trait Recall<const P: usize = { rbp_core::N }> {
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Recall::head`
[INFO] [stdout] ...
[INFO] [stdout]  41 |     fn head(&self) -> Game<P> {
[INFO] [stdout]     |        ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 384 |         let _actual_game = recall.head();
[INFO] [stdout]     |                                   ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout]     = note: required for `rbp_gameplay::Partial<_>` to implement `rbp_gameplay::Recall<_>`
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 387 |             .history()
[INFO] [stdout]     |              ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Recall::history`
[INFO] [stdout]    --> crates/gameplay/src/recall.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 | pub trait Recall<const P: usize = { rbp_core::N }> {
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Recall::history`
[INFO] [stdout] ...
[INFO] [stdout]  71 |     fn history(&self) -> Vec<Edge> {
[INFO] [stdout]     |        ------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 387 |             .history()
[INFO] [stdout]     |              ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout]     = note: required for `rbp_gameplay::Partial<_>` to implement `rbp_gameplay::Recall<_>`
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `game::NlheGame<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:390:38
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                   --------           ^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `game::NlheGame`
[INFO] [stdout]    --> crates/nlhe/src/game.rs:12:21
[INFO] [stdout]     |
[INFO] [stdout]  12 | pub struct NlheGame<const P: usize = { rbp_core::N }>(Game<P>);
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `NlheGame`
[INFO] [stdout] help: consider giving this closure parameter an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g: game::NlheGame<P>, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                       +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `game::NlheGame<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:390:38
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                   --------           ^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required for `game::NlheGame<_>` to implement `Clone`
[INFO] [stdout]    --> crates/nlhe/src/game.rs:12:12
[INFO] [stdout]     |
[INFO] [stdout]  11 | #[derive(Debug, Clone, Copy, PartialEq, Eq)]
[INFO] [stdout]     |                 ----- in this derive macro expansion
[INFO] [stdout]  12 | pub struct NlheGame<const P: usize = { rbp_core::N }>(Game<P>);
[INFO] [stdout]     |            ^^^^^^^^ -------------------------------- type parameter would need to implement `Clone`
[INFO] [stdout]     = help: consider manually implementing `Clone` to avoid undesired bounds
[INFO] [stdout] note: required by a bound in `rbp_mccfr::CfrGame::root`
[INFO] [stdout]    --> crates/mccfr/src/state/game.rs:21:20
[INFO] [stdout]     |
[INFO] [stdout]  21 | pub trait CfrGame: Clone + Copy + Send + Sync {
[INFO] [stdout]     |                    ^^^^^ required by this bound in `CfrGame::root`
[INFO] [stdout] ...
[INFO] [stdout]  24 |     fn root() -> Self;
[INFO] [stdout]     |        ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving this closure parameter an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g: game::NlheGame<P>, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                       +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `game::NlheGame<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:390:38
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                   --------           ^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required for `game::NlheGame<_>` to implement `Copy`
[INFO] [stdout]    --> crates/nlhe/src/game.rs:12:12
[INFO] [stdout]     |
[INFO] [stdout]  11 | #[derive(Debug, Clone, Copy, PartialEq, Eq)]
[INFO] [stdout]     |                        ---- in this derive macro expansion
[INFO] [stdout]  12 | pub struct NlheGame<const P: usize = { rbp_core::N }>(Game<P>);
[INFO] [stdout]     |            ^^^^^^^^ -------------------------------- type parameter would need to implement `Copy`
[INFO] [stdout] note: required by a bound in `rbp_mccfr::CfrGame::root`
[INFO] [stdout]    --> crates/mccfr/src/state/game.rs:21:28
[INFO] [stdout]     |
[INFO] [stdout]  21 | pub trait CfrGame: Clone + Copy + Send + Sync {
[INFO] [stdout]     |                            ^^^^ required by this bound in `CfrGame::root`
[INFO] [stdout] ...
[INFO] [stdout]  24 |     fn root() -> Self;
[INFO] [stdout]     |        ---- required by a bound in this associated function
[INFO] [stdout] help: consider giving this closure parameter an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g: game::NlheGame<P>, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                       +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `game::NlheGame<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:390:38
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                   --------           ^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required for `game::NlheGame<_>` to implement `rbp_mccfr::CfrGame`
[INFO] [stdout]    --> crates/nlhe/src/game.rs:25:22
[INFO] [stdout]     |
[INFO] [stdout]  25 | impl<const P: usize> CfrGame for NlheGame<P> {
[INFO] [stdout]     |      --------------  ^^^^^^^     ^^^^^^^^^^^
[INFO] [stdout]     |      |
[INFO] [stdout]     |      unsatisfied trait bound introduced here
[INFO] [stdout] help: consider giving this closure parameter an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g: game::NlheGame<P>, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                       +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `game::NlheGame<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:390:38
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                      ^     -------------- -- type must be known at this point
[INFO] [stdout]     |                                            |
[INFO] [stdout]     |                                            required by a bound introduced by this call
[INFO] [stdout]     |
[INFO] [stdout] note: required for `game::NlheGame<_>` to implement `Clone`
[INFO] [stdout]    --> crates/nlhe/src/game.rs:12:12
[INFO] [stdout]     |
[INFO] [stdout]  11 | #[derive(Debug, Clone, Copy, PartialEq, Eq)]
[INFO] [stdout]     |                 ----- in this derive macro expansion
[INFO] [stdout]  12 | pub struct NlheGame<const P: usize = { rbp_core::N }>(Game<P>);
[INFO] [stdout]     |            ^^^^^^^^ -------------------------------- type parameter would need to implement `Clone`
[INFO] [stdout]     = help: consider manually implementing `Clone` to avoid undesired bounds
[INFO] [stdout] note: required by a bound in `apply`
[INFO] [stdout]    --> crates/mccfr/src/state/game.rs:21:20
[INFO] [stdout]     |
[INFO] [stdout]  21 | pub trait CfrGame: Clone + Copy + Send + Sync {
[INFO] [stdout]     |                    ^^^^^ required by this bound in `CfrGame::apply`
[INFO] [stdout] ...
[INFO] [stdout]  26 |     fn apply(&self, edge: Self::E) -> Self;
[INFO] [stdout]     |        ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving this closure parameter an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g: game::NlheGame<P>, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                       +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `game::NlheGame<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:390:38
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                      ^     -------------- -- type must be known at this point
[INFO] [stdout]     |                                            |
[INFO] [stdout]     |                                            required by a bound introduced by this call
[INFO] [stdout]     |
[INFO] [stdout] note: required for `game::NlheGame<_>` to implement `Copy`
[INFO] [stdout]    --> crates/nlhe/src/game.rs:12:12
[INFO] [stdout]     |
[INFO] [stdout]  11 | #[derive(Debug, Clone, Copy, PartialEq, Eq)]
[INFO] [stdout]     |                        ---- in this derive macro expansion
[INFO] [stdout]  12 | pub struct NlheGame<const P: usize = { rbp_core::N }>(Game<P>);
[INFO] [stdout]     |            ^^^^^^^^ -------------------------------- type parameter would need to implement `Copy`
[INFO] [stdout] note: required by a bound in `apply`
[INFO] [stdout]    --> crates/mccfr/src/state/game.rs:21:28
[INFO] [stdout]     |
[INFO] [stdout]  21 | pub trait CfrGame: Clone + Copy + Send + Sync {
[INFO] [stdout]     |                            ^^^^ required by this bound in `CfrGame::apply`
[INFO] [stdout] ...
[INFO] [stdout]  26 |     fn apply(&self, edge: Self::E) -> Self;
[INFO] [stdout]     |        ----- required by a bound in this associated function
[INFO] [stdout] help: consider giving this closure parameter an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g: game::NlheGame<P>, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                       +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `game::NlheGame<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:390:38
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                      ^     -------------- -- type must be known at this point
[INFO] [stdout]     |                                            |
[INFO] [stdout]     |                                            required by a bound introduced by this call
[INFO] [stdout]     |
[INFO] [stdout] note: required for `game::NlheGame<_>` to implement `rbp_mccfr::CfrGame`
[INFO] [stdout]    --> crates/nlhe/src/game.rs:25:22
[INFO] [stdout]     |
[INFO] [stdout]  25 | impl<const P: usize> CfrGame for NlheGame<P> {
[INFO] [stdout]     |      --------------  ^^^^^^^     ^^^^^^^^^^^
[INFO] [stdout]     |      |
[INFO] [stdout]     |      unsatisfied trait bound introduced here
[INFO] [stdout] help: consider giving this closure parameter an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g: game::NlheGame<P>, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                       +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `game::NlheGame<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:390:38
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                      ^     --------------------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required for `game::NlheGame<_>` to implement `rbp_mccfr::CfrGame`
[INFO] [stdout]    --> crates/nlhe/src/game.rs:25:22
[INFO] [stdout]     |
[INFO] [stdout]  25 | impl<const P: usize> CfrGame for NlheGame<P> {
[INFO] [stdout]     |      --------------  ^^^^^^^     ^^^^^^^^^^^
[INFO] [stdout]     |      |
[INFO] [stdout]     |      unsatisfied trait bound introduced here
[INFO] [stdout] help: consider giving this closure parameter an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g: game::NlheGame<P>, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                       +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `game::NlheGame<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:390:38
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                      ^
[INFO] [stdout] 391 |         let canonical_choices = Game::from(canonical_game).choices(recall.subgame().aggression());
[INFO] [stdout]     |                                 ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:29:17
[INFO] [stdout]     |
[INFO] [stdout]  29 | pub struct Game<const P: usize = { rbp_core::N }> {
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Game`
[INFO] [stdout] help: consider giving this closure parameter an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g: game::NlheGame<P>, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                       +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `game::NlheGame<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:390:38
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                      ^
[INFO] [stdout] 391 |         let canonical_choices = Game::from(canonical_game).choices(recall.subgame().aggression());
[INFO] [stdout]     |                                 ---- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required for `rbp_gameplay::Game<_>` to implement `From<game::NlheGame<_>>`
[INFO] [stdout]    --> crates/nlhe/src/game.rs:53:22
[INFO] [stdout]     |
[INFO] [stdout]  53 | impl<const P: usize> From<NlheGame<P>> for Game<P> {
[INFO] [stdout]     |      --------------  ^^^^^^^^^^^^^^^^^     ^^^^^^^
[INFO] [stdout]     |      |
[INFO] [stdout]     |      unsatisfied trait bound introduced here
[INFO] [stdout] help: consider giving this closure parameter an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g: game::NlheGame<P>, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                       +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `game::NlheGame<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:390:38
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                      ^
[INFO] [stdout] 391 |         let canonical_choices = Game::from(canonical_game).choices(recall.subgame().aggression());
[INFO] [stdout]     |                                                            ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `rbp_gameplay::Game::<P>::choices`
[INFO] [stdout]    --> crates/gameplay/src/game.rs:682:6
[INFO] [stdout]     |
[INFO] [stdout] 682 | impl<const P: usize> Game<P> {
[INFO] [stdout]     |      ^^^^^^^^^^^^^^ required by this const generic parameter in `Game::<P>::choices`
[INFO] [stdout] ...
[INFO] [stdout] 685 |     pub fn choices(&self, depth: usize) -> Path {
[INFO] [stdout]     |            ------- required by a bound in this associated function
[INFO] [stdout] help: consider giving this closure parameter an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 390 |             .fold(NlheGame::root(), |g: game::NlheGame<P>, e| CfrGame::apply(&g, e));
[INFO] [stdout]     |                                       +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 391 |         let canonical_choices = Game::from(canonical_game).choices(recall.subgame().aggression());
[INFO] [stdout]     |                                                                           ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required by a const generic parameter in `subgame`
[INFO] [stdout]    --> crates/gameplay/src/recall.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 | pub trait Recall<const P: usize = { rbp_core::N }> {
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Recall::subgame`
[INFO] [stdout] ...
[INFO] [stdout]  88 |     fn subgame(&self) -> Path {
[INFO] [stdout]     |        ------- required by a bound in this associated function
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 391 |         let canonical_choices = Game::from(canonical_game).choices(recall.subgame().aggression());
[INFO] [stdout]     |                                                                           ------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout]     = note: required for `rbp_gameplay::Partial<_>` to implement `rbp_gameplay::Recall<_>`
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0284]: type annotations needed for `rbp_gameplay::Partial<_>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:375:13
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 394 |         let info = NlheInfo::from((&recall, abs));
[INFO] [stdout]     |                    -------- type must be known at this point
[INFO] [stdout]     |
[INFO] [stdout] note: required for `info::NlheInfo` to implement `From<(&rbp_gameplay::Partial<_>, rbp_gameplay::Abstraction)>`
[INFO] [stdout]    --> crates/nlhe/src/info.rs:87:22
[INFO] [stdout]     |
[INFO] [stdout]  87 | impl<const P: usize> From<(&Partial<P>, Abstraction)> for NlheInfo {
[INFO] [stdout]     |      --------------  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^
[INFO] [stdout]     |      |
[INFO] [stdout]     |      unsatisfied trait bound introduced here
[INFO] [stdout] help: consider giving `recall` an explicit type, where the value of const parameter `P` is specified
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let recall: rbp_gameplay::Partial<P> = Partial::from((Turn::Choice(0), Arrangement::from(Street::Flop)))
[INFO] [stdout]     |                   ++++++++++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about this error, try `rustc --explain E0284`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `rbp-nlhe` (lib test) due to 91 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] running `Command { std: "docker" "inspect" "08b3a850d7454f299f9f78d21ce8fb67c46a2dda151dbeb4f05afa1bd63e3b97", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "08b3a850d7454f299f9f78d21ce8fb67c46a2dda151dbeb4f05afa1bd63e3b97", kill_on_drop: false }`
[INFO] [stdout] 08b3a850d7454f299f9f78d21ce8fb67c46a2dda151dbeb4f05afa1bd63e3b97
